package main

import (
	"errors"
	"fmt"
	"math"
	"math/rand"
	"strconv"
	"strings"
	"time"
)

func AddUpper() func() int {
	var age = 1
	return func() int {
		age++
		return age
	}
}

func makesuffix(path string) func(string) string {
	return func(suffix string) string {
		if !strings.HasSuffix(path, suffix) {
			return path + suffix
		}
		return path
	}
}

func sum11(n1 int, n2 int) int {
	defer fmt.Println("ok1 n1=", n1)
	defer fmt.Println("ok2 n2=", n2)

	n1++
	n2++
	res := n1 + n2

	fmt.Println("ok3 res=", res)
	return res
}

func dump(arr [][]int) {
	for _, v := range arr {
		for _, v2 := range v {
			fmt.Print(v2, " ")
		}
		fmt.Println()
	}
	fmt.Println()
}

//平铺一组数据， 以斜对角为对折线， 交换相应位置的值
func swapNum() {
	arr := [][]int{
		{1, 2, 3},
		{4, 5, 6},
		{7, 8, 9},
	}
	fmt.Println(arr[0][0])
	// {1, 4, 7},  0,0 => 0,0; 0,1 => 1,0; 0,2 => 2,0; x不变 y从x开始递增 交换 x 和 y坐标互换位置
	// {2, 5, 8},  1,1 => 1,1; 1,2 => 2,1;
	// {3, 6, 9},  2,2 => 2,2;
	dump(arr)
	for i := 0; i < len(arr); i++ {
		for j := i + 1; j < len(arr); j++ {
			arr[i][j] = arr[i][j] + arr[j][i]
			arr[j][i] = arr[i][j] - arr[j][i]
			arr[i][j] = arr[i][j] - arr[j][i]
		}
	}
	dump(arr)
}

func exchangeValue() {
	var a = 1
	var b = 2
	fmt.Println("a=", a, "b=", b)
	// a = a + b
	// b = a - b
	// a = a - b
	// fmt.Println("a=", a, "b=", b)
	// 0,1 => 1,0
	// 0,2 => 2,0
	// 1,2 => 2,1

	//1  01
	//2  10
	//   11
	a = a ^ b
	b = a ^ b
	a = a ^ b
	fmt.Println("a=", a, "b=", b)
	// 0000 0101
	// 0000 0111
	// 0000 0000
	// 此时做位清空运算符，为后数为0，则用前数对应位代替，后数为1则取0，最终得到结果0000 0000
	fmt.Println("取反", a&^b)
}

func testLen() {
	//统计字符串和数组的长度
	arr := []int{1, 2, 3}
	print(len(arr))

	//遍历字符串，包含中文
	str := "hello北京"
	rune2 := []rune(str)
	for i := 0; i < len(rune2); i++ {
		fmt.Printf("字符为：%c\n", rune2[i])
	}

	res, err := strconv.Atoi("33")
	if err != nil {
		fmt.Println("转换失败, err:%v", err)
	}
	fmt.Println(res)
	fmt.Printf("%T, %v\n", strconv.Itoa(1111), strconv.Itoa(1111))

	byte2 := []byte("hello world")
	for i := 0; i < len(byte2); i++ {
		fmt.Printf("%d\n", byte2[i])
	}

	fmt.Printf("%s\n", strconv.FormatInt(int64(44), 2))

	str1 := "abc中中中"
	str2 := "中"
	fmt.Printf("'%s' 中是否包含 '%s', res:%v\n", str1, str2, strings.Contains(str1, str2))

	fmt.Printf("'%s' 中出现 '%s' 的次数为：%d\n", str1, str2, strings.Count(str1, str2))

	//判断两个变量是否相等， 方法两种
	//1种 两个等号 “==” 区分大小写
	//2种 strings.equalFold()
	fmt.Printf("字符串 %s 和字符串 %s 是否相等 res:%v\n", "a", "A", strings.EqualFold("a", "A"))
	fmt.Printf(" '%s' 和 '%s' 是否相等 res:%v\n", "a", "A", "a" == "A")

	//判断一个字符串 在另外一个字符串中的索引位置
	fmt.Printf("'%s' 中字符串 '%s' 中的索引位置为： %v\n", "abc", "b", strings.Index("abc", "b"))
	fmt.Printf("'%s' 中字符串 '%s' 中的索引位置为： %v\n", "abc", "b", strings.LastIndex("abbc", "b"))

	strReplace := "1abc abc 1"
	strold := "abc"
	strnew := "b"
	fmt.Printf("在字符串：'%s'中， 用字符串：'%s' 替换字符串 '%s' 结果为:%s\n", strReplace, strold, strnew, strings.Replace(strReplace, strold, strnew, 1))
	fmt.Printf("在字符串：'%s'中， 用字符串：'%s' 替换字符串 '%s' 结果为:%s\n", strReplace, strold, strnew, strings.ReplaceAll(strReplace, strold, strnew))

	strSplit := "a|b|c"
	arr22 := strings.Split(strSplit, "|")
	fmt.Printf("%v\n", arr22)
	for i := 0; i < len(arr22); i++ {
		fmt.Printf("%v\n", arr22[i])
	}

	strLowUper := "aBc"
	fmt.Printf("str='%s', 处理之后 str='%s'\n", strLowUper, strings.ToLower(strLowUper))
	fmt.Printf("str='%s', 处理之后 str='%s'\n", strLowUper, strings.ToUpper(strLowUper))

	strTrim := " 123 "
	strTrim2 := "aa 123 aa"
	strTrim2Left := "aa 123 aa"
	fmt.Printf("str=%q\n", strings.Trim(strTrim, " "))
	fmt.Printf("str=%q\n", strings.Trim(strTrim2, "a"))
	fmt.Printf("str=%q\n", strings.TrimLeft(strTrim2Left, "a"))

	strHasSuffix := "/a/b/c/d.txt"
	fmt.Printf("str=%s, 是否以TXT结尾, 结果为:%v\n", strHasSuffix, strings.HasSuffix(strHasSuffix, ".txt"))
	fmt.Printf("str=%s, 是否以TXT结尾, 结果为:%v\n", strHasSuffix, strings.HasPrefix(strHasSuffix, "/a/b"))
}

func testTime() {
	now := time.Now()
	fmt.Printf("获取当前系统时间:%v, %T\n", now, now)
	fmt.Printf("当前年月日 %0.2d-%0.2d-%0.2d %0.2d:%0.2d:%0.2d \n", now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second())
	fmt.Printf("%s\n", now.Format("2006-01-02 15:04:05")) //这个数字都是固定的

	// i := 0
	// for {
	// 	fmt.Println(i)
	// 	fmt.Println(time.Now().UnixNano())
	// 	time.Sleep(time.Millisecond * 100)
	// 	if i >= 100 {
	// 		break
	// 	}
	// 	i++
	// }

	startTime := time.Now()
	fmt.Printf("unix时间戳=%v, unixnano=%v\n", time.Now().Unix(), time.Now().UnixNano())
	str := ""
	for i := 0; i < 100000; i++ {
		str += "hello " + strconv.Itoa(i)
	}
	fmt.Printf("总共话费时间为:%vs\n", time.Now().Unix()-startTime.Unix())

}

func testBuildin() {
	num1 := 100
	num2 := new(int)
	fmt.Printf("num1的类型%T, num1的值:%v, num1的地址:%p\n", num1, num1, &num1)
	*num2 = 200
	fmt.Printf("num2的类型%T, num2的值:%v, num2的地址:%p, num2的值为:%v\n", num2, num2, &num2, *num2)

	num3 := 10
	num4 := 0
	defer func() {
		fmt.Println(recover())
	}()
	res := num3 / num4
	fmt.Printf("num3/num4=%v\n", res)
}
func inArray(num int, arr []int) bool {
	for i := 0; i < len(arr); i++ {
		if arr[i] == num {
			return true
		}
	}
	return false
}

func makeArray(start int, end int) (arr []int) {
	for i := start; i <= end; i++ {
		arr[i] = i
	}
	return
}

func IsPrimeII(num int) bool {
	if num > 2 && num%2 == 0 {
		return false
	}
	for i := 2; i < int(math.Ceil(math.Sqrt(float64(num)))); i++ {
		if num%i == 0 {
			return false
		}
	}
	return true
}

func strRepeat(str string, length int) string {
	if len(str) < length {
		for i := 0; i < length-len(str); i++ {
			str = " " + str
		}
	}
	return str
}

func testQuestion() {
	propu := func(txt string, title *int) {
		fmt.Print("请输入月份:")
		for {
			fmt.Scanln(title)
			if *title <= 0 {
				fmt.Printf("输入的%v(%v)有误", txt, *title)
				continue
			}
			fmt.Printf("您输入的%v为:%v\n", txt, *title)
			break
		}
	}

	var year int
	propu("年份", &year)
	var month int
	propu("月份", &month)
	num := 0

	switch {
	case month == 2:
		if year%4 == 0 {
			num = 28
		} else {
			num = 29
		}
	case inArray(month, []int{1, 3, 5, 7, 8, 10, 12}):
		num = 31
	default:
		num = 30
	}
	fmt.Printf("你输入的月份为:%v-%v, 该月具有%v天\n", year, month, num)
}

func testQuestion1() {
	guess := func() bool {
		fmt.Printf("随机生成一个1-100的数 如果猜对了有惊喜\n")
		rand.Seed(time.Now().UnixNano())
		for i := 1; i <= 10; i++ {
			var input int
			num := rand.Intn(100) + 1
			fmt.Printf("随机生成的数为:%v\n", num)
			fmt.Printf("请输入一个数:")
			fmt.Scanln(&input)
			if num == input {
				switch {
				case i == 1:
					fmt.Printf("你真是个天才\n")
				case inArray(i, []int{2, 3}):
					fmt.Printf("你很聪明赶上我了\n")
				case inArray(i, makeArray(4, 9)):
					fmt.Printf("\n")
				case i == 10:
					fmt.Printf("可算猜对了\n")
				}
				return true
			} else {
				fmt.Printf("你输入的数据不对!\n")
			}
		}
		return false
	}
	if !guess() {
		fmt.Printf("说你点啥好呢\n")
	}
}
func testQuestion2() {
	//编写一个函数,输出100以内的所有素数, 每行显示5个,并求和
	var list []int
	for i := 0; i < 100; i++ {
		if IsPrimeII(i) {
			list = append(list, i)
		}
	}
	sum := 0
	for i := 0; i < len(list); i++ {
		fmt.Print(i)
		fmt.Print("\t")
		sum += list[i]
		if (i+1)%5 == 0 {
			fmt.Println()
		}
	}
	fmt.Printf("100以内的所有素数的和为:%v\n", sum)
}

func testQuestion3() {
	//中国有句俗语叫 "三天打鱼两条晒网", 如果从1990年1月1日起始开始执行 "三天 打鱼两天晒网" . 如何判断 在以后的某天中是"打鱼" 还是晒网
	startTime, err := time.Parse("2006-01-02 15:04:05", "1990-01-01 00:00:00")
	if err != nil {
		fmt.Println("err=", err)
		return
	}
	hour := time.Now().Sub(startTime).Hours()
	fmt.Printf("相隔%v个小时\n", hour)
	interval := int(hour / 24)
	fmt.Printf("余数为:%v\n", interval)
	if interval%5 < 4 {
		fmt.Println("打鱼")
	} else {
		fmt.Println("晒网")
	}
}

func testQuestion4() {
	arr := [...][2]string{
		{"加法", "+"},
		{"减法", "-"},
		{"乘法", "*"},
		{"除法", "/"},
		{"退出", ""},
	}
for1:
	for {
		for i := 0; i < len(arr); i++ {
			fmt.Printf("%v.%v\n", i+1, arr[i][0])
		}
		var input int
		fmt.Print("请选择:")
		fmt.Scanln(&input)
		if input < 0 || input > 4 {
			fmt.Printf("参数(%v)有误\n", input)
			continue
		}
		num := 0
		switch input {
		case 1:
			num = 10 + 5
		case 2:
			num = 10 - 5
		case 3:
			num = 10 * 5
		case 4:
			num = 10 / 5
		case 0:
			break for1
		}
		fmt.Printf("10 %v 5 = %v\n", arr[input-1][1], num)
	}
	fmt.Println("程序退出")
}
func testQuestion5() {
	for i := 'a'; i <= 'z'; i++ {
		fmt.Printf("当前字符为:%c\n", i)
	}
	for i := 'A'; i <= 'Z'; i++ {
		fmt.Printf("当前字符为:%c\n", i)
	}
}
func test001(arr *[3]int) {
	arr[0] = 11
}

func fbn(num int) []int64 {
	slice := make([]int64, num)

	slice[0] = 1
	slice[1] = 1
	for i := 2; i < num; i++ {
		slice[i] = slice[i-1] + slice[i-2]
	}
	return slice
}

func BubbleSort(arr *[5]int) {
	fmt.Println(*arr)
	temp := 0
	llen := len(arr)
	for j := 0; j < llen-1; j++ {
		for i := 0; i < llen-1-i; i++ {
			if (*arr)[i] > (*arr)[i+1] {
				temp = (*arr)[i]
				(*arr)[i] = (*arr)[i+1]
				(*arr)[i+1] = temp
			}
		}
	}
	fmt.Println(*arr)
}

func BinaryFind(arr *[5]int, leftIndex int, rightIndex, findValue int) {
	if leftIndex > rightIndex {
		fmt.Printf("未找到\n")
		return
	}
	middle := (leftIndex + rightIndex) / 2
	if (*arr)[middle] > findValue {
		BinaryFind(arr, leftIndex, middle-1, findValue)
	} else if (*arr)[middle] < findValue {
		BinaryFind(arr, middle+1, rightIndex, findValue)
	} else {
		fmt.Printf("找到了,索引为: %v \n", middle)
	}
}

func searchMaxMin(arr *[5]int) {
	min := (*arr)[0]
	max := (*arr)[0]
	for i := 0; i < len(arr); i++ {
		if min > (*arr)[i] {
			min = (*arr)[i]
		}
		if max < (*arr)[i] {
			max = (*arr)[i]
		}
	}
	fmt.Printf("arr=%v, max:%v, min:%v\n", *arr, max, min)
}

type A struct {
	Num int `json:"num"`
}
type B struct {
	Num int `json:"num"`
	int
	n int
	string
	s string
}

type C struct {
	A
	B
}

type inter1 interface {
	sya()
}
type inter2 interface {
	sya()
}
type std struct {
	Name string
}

func (s std) sya() {
	fmt.Println(s.Name)
}

type Point struct {
	x int
	y int
}

type Usb interface {
	Start()
	Stop()
}

type Phone struct {
	Name string
}

func (p Phone) Start() {
	fmt.Println("手机开始...")
}
func (p Phone) Stop() {
	fmt.Println("手机结束...")
}
func (p Phone) Call() {
	fmt.Println("手机打电话...")
}

type Camera struct {
	Name string
}

func (p Camera) Start() {
	fmt.Println("相机开始...")
}

func (p Camera) Stop() {
	fmt.Println("相机结束...")
}

type Computer struct {
}

func (w *Computer) working(usb Usb) {
	usb.Start()
	if phone, ok := usb.(Phone); ok {
		phone.Call()
	}
	usb.Stop()
}

func TypeJudge(items ...interface{}) {
	for index, v := range items {
		switch v.(type) {
		case bool:
			fmt.Printf("第%v个参数是 bool 类型, 值是%v\n", index, v)
		case int:
			fmt.Printf("第%v个参数是 int 类型, 值是%v\n", index, v)
		case byte:
			fmt.Printf("第%v个参数是 byte 类型, 值是%v\n", index, v)
		case int8:
			fmt.Printf("第%v个参数是 int8 类型, 值是%v\n", index, v)
		case int16:
			fmt.Printf("第%v个参数是 int16 类型, 值是%v\n", index, v)
		case int32:
			fmt.Printf("第%v个参数是 int32 类型, 值是%v\n", index, v)
		case int64:
			fmt.Printf("第%v个参数是 int64 类型, 值是%v\n", index, v)
		case float32:
			fmt.Printf("第%v个参数是 float32 类型, 值是%v\n", index, v)
		case float64:
			fmt.Printf("第%v个参数是 float64 类型, 值是%v\n", index, v)
		case string:
			fmt.Printf("第%v个参数是 string 类型, 值是%v\n", index, v)
		case map[string]string:
			fmt.Printf("第%v个参数是 map[int]string 类型, 值是%v\n", index, v)
		default:
			fmt.Printf("第%v个参数是 不确定类型\n", index)
		}
	}
}

func main() {

	// n1 := 1
	// n2 := float32(1)
	// n3 := float64(1)
	// n4 := "11"
	// n5 := map[string]string{}

	// TypeJudge(n1, n2, n3, n4, n5)

	// var usbArr [3]Usb
	// usbArr[0] = Phone{"vivo"}
	// usbArr[1] = Phone{"小米"}
	// usbArr[2] = Camera{"尼康"}
	// var com Computer
	// for _, v := range usbArr {
	// 	com.working(v)
	// }

	// var x interface{}
	// var f2 float32 = 1.1
	// x = f2
	// if var2, ok := x.(float32); ok {
	// 	fmt.Println("convert success")
	// 	fmt.Printf("var2的类型是%T 只是=%v\n", var2, var2)
	// } else {
	// 	fmt.Println("convert fail")
	// }
	// fmt.Println("继续执行...")

	// var a interface{}
	// var p = Point{1, 2}
	// a = p

	// var b Point
	// b = a.(Point)
	// fmt.Println(b)

	// var v = std{}
	// var i inter1 = v
	// i.sya()

	// var st std
	// st.Name = "11"
	// st.sya()

	// var b B
	// b.Num = 1
	// b.int = 1
	// b.n = 33
	// b.string = "1"
	// b.s = "2"

	// var a A
	// var b B
	// a = A(b)
	// fmt.Println(a, b)

	// arr := map[int]string{
	// 	1: "a",
	// 	3: "c",
	// 	2: "b",
	// }
	// var keys []int
	// for k, _ := range arr {
	// 	keys = append(keys, k)
	// }
	// sort.Ints(keys)

	// for i := 0; i < len(keys); i++ {
	// 	fmt.Printf("%v\t", arr[keys[i]])
	// }
	// fmt.Println()

	// var m1 = map[string]string{
	// 	"aa":  "abc",
	// 	"aa2": "abc",
	// }
	// delete(m1, "aa")
	// fmt.Printf("%q\n", m1)

	// var m1 map[string]string
	// m1 = make(map[string]string, 1)
	// m1["a"] = "1"
	// m1["b"] = "1"
	// m1["c"] = "1"
	// fmt.Printf("%v\n", m1)

	//跳水比赛,8个评分,运动员的成绩是8个成绩去掉一个最高分,去掉一个最低分,剩下的6个分数的平均分就是最后得分,使用一维数组实现如下功能:
	//1)请吧打最高分的评委和最低分的评委找出来
	//2)找出最佳评委和最差评委,最佳评委就是打分和最后得分最接近的评委,最差评委就是打分和最后得分相差最大的.
	// arr := []int{99, 89, 87, 120, 99, 95, 90, 91}
	// max := 0
	// min := 0
	// arg := 0
	// sum := 0
	// maxx := 0
	// minn := 0
	// for i := 1; i < len(arr); i++ {
	// 	if arr[i] > arr[max] {
	// 		max = i
	// 	}
	// 	if arr[i] < min {
	// 		min = i
	// 	}
	// }
	// fmt.Printf("去掉之前各分数为:%v\n", arr)
	// for i := 0; i < len(arr); i++ {
	// 	if i != min && i != max {
	// 		sum += arr[i]
	// 	}
	// }
	// arg = sum / len(arr)
	// for i := 1; i < len(arr); i++ {
	// 	if math.Abs(float64(arg)-float64(arr[i])) < math.Abs(float64(arg)-float64(arr[minn])) {
	// 		minn = i
	// 	}
	// 	if math.Abs(float64(arg)-float64(arr[i])) > math.Abs(float64(arg)-float64(arr[maxx])) {
	// 		maxx = i
	// 	}
	// }
	// fmt.Printf("去掉一个最高分为:%v, 去掉一个最低分为:%v, 得出的平均分为:%v, 得出的最差评委就是:%v, 得出的最好评委就是:%v\n", arr[max], arr[min], arg, arr[maxx], arr[minn])

	//定义一个数组,并给出8个整数,求出该数组中大于平均值的数的个数,和小于平均值的数的个数
	// arr := []int{5, 22, 7, 9, 55, 21, 43, 67}
	// sum := 0
	// for i := 0; i < len(arr); i++ {
	// 	sum += arr[i]
	// }
	// arg := sum / len(arr)
	// max := 0
	// min := 0
	// for i := 0; i < len(arr); i++ {
	// 	if arr[i] > arg {
	// 		max++
	// 	}
	// 	if arr[i] < arg {
	// 		min++
	// 	}
	// }
	// fmt.Printf("大于平均值的个数:%v, 小于平均值的个数为:%v\n", max, min)

	//编写一个函数, 可以接收一个数组,该数组有5个数,请找出最大的数和最小的数和对应的数组下标是多少?
	// arr := [5]int{2, 4, 99, 12, 45}
	// searchMaxMin(&arr)

	//随机生成10个整数(1-100之间), 使用冒泡排序法进行排序,然后使用二分查找法,查找是否有90这个数,并显示下标,如果没有则提示"找不到该数"
	// arr := [5]int{}
	// rand.Seed(time.Now().UnixNano())
	// for i := 0; i < 5; i++ {
	// 	arr[i] = rand.Intn(100) + 1
	// }
	// fmt.Printf("排序前arr=%v\n", arr)
	// for i := 0; i < len(arr)-1; i++ {
	// 	for j := 0; j < len(arr)-1-i; j++ {
	// 		if arr[j] > arr[j+1] {
	// 			arr[j] = arr[j] ^ arr[j+1]
	// 			arr[j+1] = arr[j] ^ arr[j+1]
	// 			arr[j] = arr[j] ^ arr[j+1]
	// 		}
	// 	}
	// }
	// fmt.Printf("排序后arr=%v\n", arr)
	// BinaryFind(&arr, 0, len(arr)-1, 90)

	//试写出实现查找的核心代码,比如已知数组 arr[10]string;里面保存了是个元素,现要查找"AA" 在其中是否存在,打印提示,如果有多个 "AA", 也要找到对应的下标
	// arr := []string{"a", "b", "c", "b"}
	// findStr := "b"
	// for i := 0; i < len(arr); i++ {
	// 	if arr[i] == findStr {
	// 		fmt.Printf("找到该元素了, 其值为:%v, 下标为:%v\n", arr[i], i)
	// 	}
	// }

	//试保存 1 3 5 7 9 五个奇数保存到数组, 并倒序打印
	// arr := []int{1, 3, 5, 9}
	// fmt.Printf("%v\n", arr)
	// for i := len(arr) - 1; i >= 0; i-- {
	// 	fmt.Printf("第%v个数为:%v\n", i, arr[i])
	// }

	//定义一个4行4列的二维数组,逐个从键盘输入值,然后将第1行和第四行的数据交换,将2行和第3行的数据进行交换
	// 1,2,3,4
	// 5,6,7,8
	// 9,0,1,2
	// 11,12,13,14

	// 第1次
	// 11,12,13,14
	// 5,6,7,8
	// 9,0,1,2
	// 1,2,3,4
	// 第2次
	// 11,12,13,14
	// 9,0,1,2
	// 5,6,7,8
	// 1,2,3,4
	// const inCycle = 4
	// const outCycle = 4
	// arr := [outCycle][inCycle]int{}
	// for i := 0; i < outCycle; i++ {
	// 	fmt.Printf("请输入4个整数,逗号隔开:")
	// 	fmt.Scanf("%d,%d,%d,%d", &arr[i][0], &arr[i][1], &arr[i][2], &arr[i][3])
	// }
	// for i := 0; i < outCycle; i++ {
	// 	fmt.Printf("%v\n", arr[i])
	// }
	// fmt.Println()
	// for i := 0; i < outCycle/2; i++ {
	// 	for j := 0; j < inCycle; j++ {
	// 		arr[i][j] = arr[i][j] ^ arr[outCycle-1-i][j]
	// 		arr[outCycle-1-i][j] = arr[i][j] ^ arr[outCycle-1-i][j]
	// 		arr[i][j] = arr[i][j] ^ arr[outCycle-1-i][j]
	// 	}
	// }
	// for i := 0; i < outCycle; i++ {
	// 	fmt.Printf("%v\n", arr[i])
	// }

	//定义一个3行4列的二维数组,逐个从键盘输入值,编写程序将四周的数据清0
	// const inCycle = 4
	// const outCycle = 3
	// arr := [outCycle][inCycle]int{}
	// for i := 0; i < outCycle; i++ {
	// 	fmt.Printf("请输入4个整数,逗号隔开:")
	// 	fmt.Scanf("%d,%d,%d,%d", &arr[i][0], &arr[i][1], &arr[i][2], &arr[i][3])

	// }
	// for i := 0; i < outCycle; i++ {
	// 	fmt.Printf("%v\n", arr[i])
	// }
	// fmt.Println()
	// for i := 0; i < outCycle; i++ {
	// 	for j := 0; j < inCycle; j++ {
	// 		if i == 0 || i == outCycle-1 || j == 0 || j == inCycle-1 {
	// 			arr[i][j] = 0
	// 		}
	// 	}
	// 	fmt.Printf("%v\n", arr[i])
	// }

	//已知有个排序好(升序)的数组,要求插入一个元素,最后打印该数组,顺序依然升序
	//待比较的数据为
	// 3
	// arr = {1, 2, 4}
	// arr1={}
	//1, 2, 4
	//第一次 arr1 = {1}				索引位置: i=0
	//第二次 arr1 = {1, 2}			索引位置: i=1
	//第三次 arr1 = {1, 2, 3}		索引位置: i=2
	//第三次 arr1 = {1, 2, 3, 4}	索引位置: i=3
	// arr := [3]int{1, 2, 4}
	// arr1 := [4]int{}
	// newVar := 3
	// isFinded := false
	// for i := 0; i < len(arr1); i++ {
	// 	if !isFinded && arr[i] >= newVar {
	// 		arr1[i] = newVar
	// 		isFinded = true
	// 	} else {
	// 		if isFinded {
	// 			arr1[i] = arr[i-1]
	// 		} else {
	// 			arr1[i] = arr[i]
	// 		}
	// 	}
	// }
	// fmt.Printf("插入后的有序数组为:%v\n", arr1)

	//随机生成10个整数(1_100的范围)保存到数组,并倒序打印以及求平均值,求最大值和最大值的下标,并查找里面是否含有55
	// arr := [10]int{}
	// rand.Seed(time.Now().UnixNano())
	// maxValue := 0
	// minValue := 0
	// sum := 0
	// is55 := false
	// for i := 0; i < 10; i++ {
	// 	arr[i] = rand.Intn(100) + 1
	// 	if arr[i] > arr[maxValue] {
	// 		maxValue = i
	// 	} else if arr[i] < arr[minValue] {
	// 		minValue = arr[i]
	// 	}
	// 	if arr[i] == 55 {
	// 		is55 = true
	// 	}
	// 	sum += arr[i]
	// }
	// for i := 0; i < len(arr)-1; i++ {
	// 	for j := 0; j < len(arr)-1-i; j++ {
	// 		if arr[j] < arr[j+1] {
	// 			arr[j] = arr[j] ^ arr[j+1]
	// 			arr[j+1] = arr[j] ^ arr[j+1]
	// 			arr[j] = arr[j] ^ arr[j+1]
	// 		}
	// 	}
	// }
	// fmt.Println(arr)
	// fmt.Printf("最大值的下标为:%v\n", arr[maxValue])
	// fmt.Printf("最大值为:%v\n", maxValue)
	// fmt.Printf("平均值的下标为:%v\n", sum/10)
	// fmt.Printf("arr 中是否存在55这个元素:%v\n", is55)

	// arr := [...][3]int{{1, 2, 3}, {4, 5, 6}}
	// fmt.Println(arr)

	// arr := [5]int{2, 3, 4, 6, 8}
	// BinaryFind(&arr, 0, 4, 8)

	// num := 10
	// fmt.Println(fbn(num))

	//字符串可以进行切片处理  字符串不能单独修改 , 需要转换 []byte  然后再修改  不能修改中文  中文按照3个字节 会出现乱码
	// str := "hello"

	// slice := str[1:]
	// println(slice)

	// b := []byte(str)
	// b[0] = 'a'
	// str = string(b)
	// fmt.Println(str)

	// a := []rune(str)
	// a[0] = '被'
	// str = string(a)
	// fmt.Println(str)

	// slice := []int{1, 2}
	// fmt.Println(slice)

	// slice := []int{1, 2, 3, 4, 5, 6}
	// slice2 := make([]int, 3)
	// copy(slice2, slice)

	// fmt.Printf("%v\n", slice)
	// fmt.Printf("%v\n", slice2)

	// arr := [3]int{17, 8, 9}
	// slice := []int{3, 4}
	// slice = append(slice, 1)
	// slice = append(slice, slice...)
	// fmt.Printf("%v\n", slice)

	// arr := []int{1, 2, 3}
	// slice := arr[:]
	// slice2 := slice[:]
	// slice2[0] = 9

	// fmt.Printf("%v\n", slice)
	// fmt.Printf("%v\n", slice2)
	// fmt.Printf("%v\n", arr)

	// slice := []int{1, 2, 3}
	// fmt.Printf("%v\n", slice)
	// fmt.Printf("len=%v\n", len(slice))
	// fmt.Printf("cap=%v\n", cap(slice))
	// for i := 0; i < len(slice); i++ {
	// 	fmt.Printf("%v\n", slice[i])
	// }
	// for k, v := range slice {
	// 	fmt.Printf("%v, %v\n", k, v)
	// }
	// fmt.Printf("%v\n", slice[1])

	// arr := make([]int, 1, 4)
	// arr[0] = 1
	// fmt.Printf("size=%v\n", len(arr))
	// fmt.Printf("cap=%v\n", cap(arr))

	// arr := [5]int{}
	// rand.Seed(time.Now().UnixNano())
	// length := len(arr)
	// for i := 0; i < length; i++ {
	// 	arr[i] = rand.Intn(100)
	// }
	// fmt.Printf("%v\n", arr)
	// for i := 0; i < length/2; i++ {
	// 	arr[i] = arr[i] + arr[length-i-1]
	// 	arr[length-i-1] = arr[i] + -arr[length-i-1]
	// 	arr[i] = arr[i] - arr[length-i-1]
	// }
	// fmt.Printf("%v\n", arr)

	// arr := [...]int{4, 2, 3, 9, 10}
	// sum := 0
	// for _, v := range arr {
	// 	sum += v
	// }
	// fmt.Printf("和为:%v\n", sum)
	// fmt.Printf("平均值:%v\n", float64(sum)/float64(len(arr)))

	// for i := 1; i < len(arr); i++ {
	// 	if arr[0] < arr[i] {
	// 		arr[0] = arr[i]
	// 	}
	// }
	// fmt.Printf("最大值为:%v\n", arr[0])

	// arr := [...]int{1, 2, 3}
	// fmt.Printf("%v\n", arr)
	// test001(&arr)
	// fmt.Printf("%v\n", arr)

	// var name = [1]interface{}{"1111"}
	// fmt.Printf("%v\n", name)

	// var arr11 [3]int
	// fmt.Printf("%p, %p, %p, %p\n", &arr11, &arr11[0], &arr11[1], &arr11[2])

	//私有全局变量包内有效
	// sum2()

	//入栈时会进行值拷贝
	// res := sum11(10, 20)
	// fmt.Println("res = ", res)

	// fmt.Println(makesuffix("/a/b/c/d.txt")(".txt"))
	// a := AddUpper()
	// fmt.Println(a())
	// fmt.Println(a())
	// fmt.Println(a())
	// fmt.Println(a())

	// str2, _ := strconv.Atoi("1")
	// fmt.Printf("%v\n", str2)

	// var str string = "123123.456"
	// b, _ := strconv.ParseInt(str, 10, 64)
	// fmt.Printf("%v\n", b)

	// var i int = 10

	// var p *int = &i
	// fmt.Printf("%v\n", p)
	// fmt.Printf("%v\n", &p)
	// fmt.Printf("%v\n", *p)

	//var num = 1
	//fmt.Printf("&num=%v\n", &num)
	//
	//var ptr *int
	//ptr = &num
	//*ptr = 10
	//fmt.Printf("num = %v\n", num)
	//
	//var _str = "aaa"
	//var ptr2 *string = &_str
	//fmt.Printf("%v\n", *ptr2)
	//fmt.Println(model.Name)

	// var a = 1
	// a++
	// a--
	// fmt.Println(a)

	// 面试题
	// var a, b = 1, 2
	// a = a + b
	// b = a - b
	// a = a - b
	// fmt.Printf("a=%v, b=%v\n", a, b)

	// var var1 string
	// fmt.Scanln(&var1)
	// fmt.Printf("var1=%v\n", var1)

	//二进制如何转十进制
	//129

	//golang Switch
	// var var1 = 9
	// switch {
	// case var1 > 2:
	// 	fmt.Println(2)
	// case var1 > 1:
	// 	fmt.Println(1)
	// default:
	// 	fmt.Println(0)
	// }

	// switch var2 := 9; {
	// case var2 > 2:
	// 	fmt.Println(2)
	// 	fallthrough
	// case var2 > 1:
	// 	fmt.Println(1)
	// 	fallthrough
	// default:
	// 	fmt.Println(0)
	// }

	// var var3 interface{}
	// var3 = var1
	// switch var3.(type) {
	// case int:
	// 	fmt.Println(1)
	// default:
	// 	fmt.Println(0)
	// }

	// var var1 = "hello,world汉字"
	// var2 := []rune(var1)
	// for i := 0; i < len(var2); i++ {
	// 	fmt.Printf("%c\n", var2[i])
	// }
	// for i, v := range var1 {
	// 	fmt.Printf("%d %c\n", i, v)
	// }

	// var count uint64
	// var sum uint64
	// for i := uint64(1); i < 100; i++ {
	// 	if i%9 == 0 {
	// 		count++
	// 		sum += i
	// 	}
	// }
	// fmt.Printf("%v, %v\n", count, sum)

	// var classNum = 3
	// var studentNum = 5
	// totalSum := 0.0
	// for j := 1; j <= classNum; j++ {
	// 	sum := 0.0
	// 	for i := 1; i <= studentNum; i++ {
	// 		fmt.Printf("请输入第%d个班，第%d个学生的成绩\n", j, i)
	// 		var score float64
	// 		fmt.Scanln(&score)
	// 		sum += score
	// 	}
	// 	fmt.Printf("班级的平均分数为：%f", sum/float64(studentNum))
	// 	totalSum += sum
	// }
	// fmt.Printf("班级的平均分数为：%f", totalSum/float64(classNum*studentNum))

	//空心金字塔
	// totalLevel := 5
	// for i := 1; i <= totalLevel; i++ {
	// 	for a := 1; a <= totalLevel-i; a++ {
	// 		fmt.Print(" ")
	// 	}
	// 	for j := 1; j <= 2*i-1; j++ {
	// 		if j == 1 || j == 2*i-1 || i == totalLevel {
	// 			fmt.Print("*")
	// 		} else {
	// 			fmt.Print(" ")
	// 		}
	// 	}
	// 	fmt.Println()
	// }
	//九九乘法表
	// fmt.Println()
	// for i := 1; i <= 9; i++ {
	// 	for j := 1; j <= i; j++ {
	// 		fmt.Printf("%d + %d = %d\t", j, i, i+j)
	// 	}
	// 	fmt.Println()
	// }

	//随机生成1-100的整数 100次 知道生成了99个数，看看你总共用了多少次
	// count := 0
	// for {
	// 	rand.Seed(time.Now().UnixNano())
	// 	n := rand.Intn(100) + 1
	// 	fmt.Println(n)
	// 	if n >= 99 {
	// 		break
	// 	}
	// 	count++
	// }
	// fmt.Printf("总共用了：%d 次\n", count)

	//break 跳出指定循环
	// for1:
	// 	for i := 0; i < 3; i++ {
	// 		for j := 0; j < 3; j++ {
	// 			if j == 2 {
	// 				break for1
	// 			}
	// 			fmt.Println("j=", j)
	// 		}
	// 	}

	//100以内的数求和， 求出当和第一次大于20的当前数
	// sum := 0
	// for i := 1; i <= 100; i++ {
	// 	sum += i
	// 	if sum > 20 {
	// 		fmt.Printf("当sum>20时，前数为：%d\n", i)
	// 		break
	// 	}
	// }

	//实现登录验证，有三次机会， 如果用户名为“张无忌” 密码“888” 提示登录成功
	// var name string
	// var pwd string
	// for i := 1; i <= 3; i++ {
	// 	fmt.Println("请输入用户名：")
	// 	fmt.Scanln(&name)
	// 	fmt.Println("请输入密码：")
	// 	fmt.Scanln(&pwd)
	// 	if name == "张无忌" && pwd == "888" {
	// 		fmt.Println("登录成功")
	// 		break
	// 	} else {
	// 		if 3-i > 0 {
	// 			fmt.Printf("你还有%v次登录机会， 请珍惜\n", 3-i)
	// 		} else {
	// 			fmt.Println("登录登录失败")
	// 		}
	// 	}
	// }

	//continue 使用
	// for1:
	// 	for i := 1; i < 3; i++ {
	// 		for j := 1; j < 4; j++ {
	// 			if j == 2 {
	// 				continue for1
	// 			}
	// 			fmt.Println(j)
	// 		}
	// 	}

	//从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序
	// var positiveCount int
	// var negativeCount int
	// var num int
	// for {
	// 	fmt.Printf("请输入一个数\n")
	// 	fmt.Scanln(&num)
	// 	if num == 0 {
	// 		break
	// 	}
	// 	if num < 0 {
	// 		negativeCount++
	// 		continue
	// 	}
	// 	positiveCount++
	// }
	// fmt.Printf("正数个数为:%d, 负数个数为：%d\n", positiveCount, negativeCount)

	//goto 演示
	// 	fmt.Println("ok1")
	// 	goto aa
	// 	fmt.Println("ok2")
	// aa:
	// 	fmt.Println("ok3")

	// fmt.Println(getSum(1, 2))
	// o1, o2, err := getSumAndSub(13, 14)
	// fmt.Println(o1, o2, err)

	//菲波那切数列
	// fmt.Println(jisuan001(1))
	// fmt.Println(jisuan001(2))
	// fmt.Println(jisuan001(3))

	// fmt.Println(chitaozi(1))

	// type myInt int
	// var a myInt
	// var b int
	// a = 1
	// b = int(a)

	// type myFunc func (int, int) int
	// fmt.Println("a=", a, "b=", b)
	// fmt.Println(funcReturn())
	// result4 := sum1(4, 1, 4, 90)
	// fmt.Println(result4)

	// res1 := func(name string) string {
	// 	return name + " ok"
	// }("lwenjim")

	// fmt.Println(res1)
}

var name = func() string {
	fmt.Println("变量被初始化")
	return "lwenjim"
}

func sum1(n1 int, args ...int) int {
	sum := n1
	for i := 0; i < len(args); i++ {
		sum += args[i]
	}
	return sum
}

func funcReturn() (a int) {
	a = 1
	return
}

func chitaozi(n int) int {
	if n >= 10 {
		return 1
	}
	return 2 * (chitaozi(n+1) + 1)
}

func jisuan001(n int) int {
	if n <= 1 {
		return 1
	}
	return 2*jisuan001(n-1) + 1
}

func feibo(n int) int {
	if n <= 2 {
		return 1
	}
	return feibo(n-2) + feibo(n-1)
}

func getSum(n1 int, n2 int) int {
	return n1 + n2
}

func getSumAndSub(n1 int, n2 int) (int, int, error) {
	return n2, n1, errors.New("sss")
}
